package org.batatasframework.properties;

import org.batatasframework.expression.Named;

import cn.bonoon.kernel.util.StringHelper;

/**
 * <pre>
 * 这里是对应属性定义文件里的name部分，解析后有两个部分的值：
 * 一个是name，一是该name带的参数。
 * 格式如：
 * name = xxxxx
 * name[zzzz] = xxxxx
 * 等
 * 其中："zzzz"可以是一个完整的指令
 * </pre>
 * @author jackson
 *
 */
public class PropertiesName {
	
	public static PropertiesName NULL = new PropertiesName();
	
	public static PropertiesName valueOf(String strName){
		return new PropertiesName(strName);
	}

	private final Named name;
	
	/**
	 * <pre>
	 * 这里定义在定义上的参数，如:[name args]
	 * 这个参数需要怎么使用，由具体的解析类进行处理
	 * </pre>
	 */
	private String argument = "";
	
	private PropertiesName(){
		this.name = Named.NULL_VALUE;
	}
	
	/**
	 * <pre>
	 * 这个是表达式的命名部分，如：name[...] = ...
	 * 这里是"name[...]"的部分
	 * </pre>
	 */
	public PropertiesName(String exp, int nameEndIndex){
		char[] temp = exp.substring(0, nameEndIndex).trim().toCharArray();
		int i = 0, j = 0;
		for(; i < temp.length; i++){
			if(temp[i] == '['){
				
				//对下一位字符进行判断
				i += 1;
				if(i < temp.length){
					
					/*
					 * 如果遇到'['符号，并且下一个符号为非'['符号的时候，则表示是定义的扩展值；
					 * 如：propertyname[ddss]=xxxx 格式
					 * 如果是：propertyname[[dds=xxx格式的，则会被处理为propertyname[dds，并且没有扩展值
					 */
					if(temp[i] != '['){
						break;
					}
				}else{
					j = temp.length;
					break;
				}
			}
			temp[j++] = temp[i];
		}
		
		int count = temp.length - i;
		if(count > 0){
			if(temp[temp.length - 1] == ']'){
				count -= 1;
			}
			argument = new String(temp, i, count);
		}
		name = Named.valueOf(new String(temp, 0, j));
	}
	
	/**
	 * <pre>
	 * 这个是属性文件的组名，如：
	 * 
	 * [group]等。
	 * </pre>
	 */
	public PropertiesName(String exp){
		String name = "";
		if(!exp.isEmpty()){
			int pi = exp.indexOf(' ');
			int el = exp.length();
			if(exp.endsWith("]")) el -= 1;//去掉最后的一个"]"
			
			if(pi > 0){
				//定义了表达式的情况
				name = exp.substring(1, pi);
				//参数
				argument = exp.substring(pi + 1, el);
			}else{
				name = exp.substring(1, el);
			}
		}
		
		this.name = Named.valueOf(name);
	}
	
	public String getArgument() {
		return argument;
	}
	
	public boolean hasArgument(){
		return StringHelper.isNotEmpty(argument);
	}
	
	public Named getName() {
		return name;
	}
	
	@Override
	public String toString() {
		return name.toString();
	}
	
	@Override
	public int hashCode() {
		return name.hashCode();
	}
	
	@Override
	public boolean equals(Object obj) {
		return this == obj || name.equals(obj);
	}
	
	//------------------
	public static String adjust(String name){
		String tn = name.trim();  //去掉前后的空格
		//Assert.isTrue(!tn.contains(" ") && !tn.contains("　"), "定义不允许出现空格：" + tn);
		if(!tn.startsWith("[")) tn = "[" + tn;
		if(tn.endsWith("]")) tn = tn.substring(0, tn.length() - 1);
		return tn;
	}
	
	public static boolean checkName(String target){
		return target.startsWith("[") && target.endsWith("]");
	}
	
	public static boolean checkName(String target, String name){
		return target.startsWith("[") && __checkName(target, name);
	}

	private static boolean __checkName(String target, String name){
		if(target.startsWith(name)){
			int nl = name.length();
			if(target.length() > nl){
				char ct = target.charAt(nl);
				if(ct == ' ' || ct == ']'){
					/*
					 * 这是"[name]"或者"[name paraments]"的情况
					 */
					return true;
				}
			}else{// 大家都是"[name"的情况
				return true;
			}
		}
		return false;
	}
	
	public static boolean checkName(String target, String... names){
		if(target.startsWith("[")){
			for(String name : names){
				if(__checkName(target, name)){
					return true;
				}
			}
		}
		return false;
	}
	
}
